p-limit

What is p-limit?

The p-limit npm package is a utility that allows you to limit the number of promises that are running at the same time. It is useful for controlling concurrency when you have operations that can be run in parallel but you want to limit the number of these operations due to resource constraints.

What are p-limit's main functionalities?

Concurrency Limiting

This feature allows you to create a limit for how many promises are allowed to run at once. In the code sample, the limit is set to 1, meaning that `doSomething` and `doAnotherThing` will not run at the same time.

const pLimit = require('p-limit');
const limit = pLimit(1);

async function doSomething() {}

async function doAnotherThing() {}

// Only one promise will run at once
const result1 = limit(() => doSomething());
const result2 = limit(() => doAnotherThing());

Queueing

This feature demonstrates how additional promises are queued when the limit is reached. In this example, only two promises will run concurrently, and the rest will wait in the queue.

const pLimit = require('p-limit');
const limit = pLimit(2);

const input = [
  limit(() => fetchSomething('foo')),
  limit(() => fetchSomething('bar')),
  limit(() => doSomethingElse()),
];

// Only two promises will run at once, the rest will be queued
Promise.all(input).then(results => {
  console.log(results);
});

Other packages similar to p-limit

bottleneck

Bottleneck is a powerful rate limiter that allows you to limit the number of calls to a function. It can be used to throttle requests to an API or any other operation that needs to be rate-limited. It is more feature-rich than p-limit, providing priorities, clustering support, and more configuration options.

async

Async provides a collection of utilities for working with asynchronous JavaScript. While it offers functions like `async.parallelLimit` which can limit the number of asynchronous operations running in parallel, it is a more comprehensive toolkit for asynchronous control flow, including series, waterfall, and eachOf methods.

p-queue

P-Queue is a promise queue with adjustable concurrency that supports priorities, timeouts, and pausing. It is similar to p-limit but offers a higher level of abstraction with a queue system, making it suitable for more complex scenarios where you need to manage the order and priority of tasks.

README

p-limit

Run multiple promise-returning & async functions with limited concurrency

Install

$ npm install p-limit

Usage

const pLimit = require('p-limit');

const limit = pLimit(1);

const input = [
	limit(() => fetchSomething('foo')),
	limit(() => fetchSomething('bar')),
	limit(() => doSomething())
];

(async () => {
	// Only one promise is run at once
	const result = await Promise.all(input);
	console.log(result);
})();

API

pLimit(concurrency)

Returns a limit function.

concurrency

Type: number
Minimum: 1

Concurrency limit.

limit(fn)

Returns the promise returned by calling fn.

fn

Type: Function

Promise-returning/async function.

Related

• p-queue - Promise queue with concurrency control
• p-throttle - Throttle promise-returning & async functions
• p-debounce - Debounce promise-returning & async functions
• p-all - Run promise-returning & async functions concurrently with optional limited concurrency
• More…

License

MIT © Sindre Sorhus